home *** CD-ROM | disk | FTP | other *** search
/ The CICA Windows Explosion! / The CICA Windows Explosion! - Disc 2.iso / programr / ole2book.zip / CHAP07.ZIP / CHAP07 / COSCHMOO / DOCUMENT.CPP < prev    next >
C/C++ Source or Header  |  1993-05-18  |  17KB  |  784 lines
  1. /*
  2.  * DOCUMENT.CPP
  3.  * Component Schmoo Chapter 7
  4.  *
  5.  * Implementation of the CSchmooDoc derivation of CDocument as
  6.  * well as an implementation of CPolylineAdviseSink.
  7.  *
  8.  * Copyright (c)1993 Microsoft Corporation, All Rights Reserved
  9.  *
  10.  * Kraig Brockschmidt, Software Design Engineer
  11.  * Microsoft Systems Developer Relations
  12.  *
  13.  * Internet  :  kraigb@microsoft.com
  14.  * Compuserve:  >INTERNET:kraigb@microsoft.com
  15.  */
  16.  
  17.  
  18. #include "coschmoo.h"
  19.  
  20.  
  21.  
  22. /*
  23.  * CSchmooDoc::CSchmooDoc
  24.  * CSchmooDoc::~CSchmooDoc
  25.  *
  26.  * Constructor Parameters:
  27.  *  hInst           HINSTANCE of the application.
  28.  */
  29.  
  30. CSchmooDoc::CSchmooDoc(HINSTANCE hInst)
  31.     : CDocument(hInst)
  32.     {
  33.     m_uPrevSize=SIZE_RESTORED;
  34.     m_pPL=NULL;
  35.     m_pIPersistStorage=NULL;
  36.  
  37.     m_pIAdviseSink=NULL;
  38.     m_dwConn=0;
  39.     return;
  40.     }
  41.  
  42.  
  43. CSchmooDoc::~CSchmooDoc(void)
  44.     {
  45.     LPDATAOBJECT        pIDataObject;
  46.     HRESULT             hr;
  47.  
  48.     //Turn off the advise.
  49.     hr=m_pPL->QueryInterface(IID_IDataObject, (LPVOID FAR *)&pIDataObject);
  50.  
  51.     if (SUCCEEDED(hr))
  52.         pIDataObject->DUnadvise(m_dwConn);
  53.  
  54.     if (NULL!=m_pIAdviseSink)
  55.         delete m_pIAdviseSink;
  56.  
  57.     if (NULL!=m_pIPersistStorage)
  58.         m_pIPersistStorage->Release();
  59.  
  60.     if (NULL!=m_pPLAdv)
  61.         delete m_pPLAdv;
  62.  
  63.     if (NULL!=m_pPL)
  64.         m_pPL->Release();
  65.  
  66.     CoFreeUnusedLibraries();
  67.     return;
  68.     }
  69.  
  70.  
  71.  
  72.  
  73.  
  74.  
  75. /*
  76.  * CSchmooDoc::FInit
  77.  *
  78.  * Purpose:
  79.  *  Initializes an already created document window.  The client actually
  80.  *  creates the window for us, then passes that here for further
  81.  *  initialization.
  82.  *
  83.  * Parameters:
  84.  *  pDI             LPDOCUMENTINIT containing initialization parameters.
  85.  *
  86.  * Return Value:
  87.  *  BOOL            TRUE if the function succeeded, FALSE otherwise.
  88.  */
  89.  
  90. BOOL CSchmooDoc::FInit(LPDOCUMENTINIT pDI)
  91.     {
  92.     RECT            rc;
  93.     HRESULT         hr;
  94.     FORMATETC       fe;
  95.     LPDATAOBJECT    pIDataObject;
  96.  
  97.     //Change the stringtable range to our customization.
  98.     pDI->idsMin=IDS_DOCUMENTMIN;
  99.     pDI->idsMax=IDS_DOCUMENTMAX;
  100.  
  101.     //Do default initialization
  102.     if (!CDocument::FInit(pDI))
  103.         return FALSE;
  104.  
  105.     //Create the Polyline Object via COMPOBJ.DLL functions.
  106.     hr=CoCreateInstance(CLSID_Polyline6, NULL, CLSCTX_INPROC_SERVER
  107.         , IID_IPolyline6, (LPVOID FAR *)&m_pPL);
  108.  
  109.     if (FAILED(hr))
  110.         return FALSE;
  111.  
  112.     //Initialize the contained Polyline which creates a window.
  113.     GetClientRect(m_hWnd, &rc);
  114.     InflateRect(&rc, -8, -8);
  115.  
  116.     if (FAILED(m_pPL->Init(m_hWnd, &rc, WS_CHILD | WS_VISIBLE, ID_POLYLINE)))
  117.         return FALSE;
  118.  
  119.  
  120.     //Set up an advise on the Polyline.
  121.     m_pPLAdv=new CPolylineAdviseSink((LPVOID)this, (LPUNKNOWN)this);
  122.  
  123.     if (NULL==m_pPLAdv)
  124.         return FALSE;
  125.  
  126.     m_pPL->SetAdvise(m_pPLAdv);
  127.  
  128.     //Get the IPersistStorage interface on the object for loads & saves.
  129.     hr=m_pPL->QueryInterface(IID_IPersistStorage, (LPVOID FAR *)&m_pIPersistStorage);
  130.  
  131.     if (FAILED(hr))
  132.         return FALSE;
  133.  
  134.     /*
  135.      * Create an IAdviseSink and send it to the Polyline's IDataObject
  136.      * with the clipboard format for the Polyline (as in IPOLY6.H).
  137.      */
  138.  
  139.     //This is a private macro.
  140.     SETDefFormatEtc(fe, m_cf, TYMED_HGLOBAL);
  141.  
  142.     m_pIAdviseSink=new CImpIAdviseSink((LPVOID)this, (LPUNKNOWN)this);
  143.  
  144.     if (NULL==m_pIAdviseSink)
  145.         return FALSE;
  146.  
  147.     //Set up an advise for the Polyline format
  148.     hr=m_pPL->QueryInterface(IID_IDataObject, (LPVOID FAR *)&pIDataObject);
  149.  
  150.     if (FAILED(hr))
  151.         return FALSE;
  152.  
  153.     pIDataObject->DAdvise(&fe, ADVF_NODATA, m_pIAdviseSink, &m_dwConn);
  154.     pIDataObject->Release();
  155.  
  156.     return TRUE;
  157.     }
  158.  
  159.  
  160.  
  161.  
  162. //IUnknown interface for all the interfaces we implement in the document
  163.  
  164. /*
  165.  * CSchmooDoc::QueryInterface
  166.  * CSchmooDoc::AddRef
  167.  * CSchmooDoc::Release
  168.  *
  169.  * Purpose:
  170.  *  IUnknown members for the CSchmooDoc implementation.
  171.  */
  172.  
  173. STDMETHODIMP CSchmooDoc::QueryInterface(REFIID riid, LPVOID FAR *ppv)
  174.     {
  175.     *ppv=NULL;
  176.  
  177.     //The document is the unknown
  178.     if (IsEqualIID(riid, IID_IUnknown))
  179.         *ppv=(LPVOID)this;
  180.  
  181.     //Return contained interfaces for others.
  182.     if (IsEqualIID(riid, IID_IPolylineAdviseSink6))
  183.         *ppv=(LPVOID)m_pPLAdv;
  184.  
  185.     if (IsEqualIID(riid, IID_IAdviseSink))
  186.         *ppv=(LPVOID)m_pIAdviseSink;
  187.  
  188.     /*
  189.      * If we actually assign an interface to ppv we need to AddRef it
  190.      * since we're returning a new pointer.
  191.      */
  192.     if (NULL!=*ppv)
  193.         {
  194.         ((LPUNKNOWN)*ppv)->AddRef();
  195.         return NOERROR;
  196.         }
  197.  
  198.     return ResultFromScode(S_FALSE);
  199.     }
  200.  
  201.  
  202. STDMETHODIMP_(ULONG) CSchmooDoc::AddRef(void)
  203.     {
  204.     return ++m_cRef;
  205.     }
  206.  
  207.  
  208. STDMETHODIMP_(ULONG) CSchmooDoc::Release(void)
  209.     {
  210.     /*
  211.      * Since CoSchmoo doesn't use documents like Component Objects, this
  212.      * doesn't do anything except provide a debugging point.
  213.      */
  214.     return --m_cRef;
  215.     }
  216.  
  217.  
  218.  
  219.  
  220.  
  221.  
  222.  
  223.  
  224. /*
  225.  * CSchmooDoc::FMessageHook
  226.  *
  227.  * Purpose:
  228.  *  Processes WM_SIZE for the document so we can resize the Polyline.
  229.  *
  230.  * Parameters:
  231.  *  <WndProc Parameters>
  232.  *  pLRes           LRESULT FAR * in which to store the return value
  233.  *                  for the message.
  234.  *
  235.  * Return Value:
  236.  *  BOOL            TRUE to prevent further processing, FALSE otherwise.
  237.  */
  238.  
  239. BOOL CSchmooDoc::FMessageHook(HWND hWnd, UINT iMsg, WPARAM wParam
  240.     , LPARAM lParam, LRESULT FAR *pLRes)
  241.     {
  242.     UINT        dx, dy;
  243.     RECT        rc;
  244.  
  245.     if (WM_SIZE==iMsg)
  246.         {
  247.         //Don't effect the Polyline size to or from minimized state.
  248.         if (SIZE_MINIMIZED!=wParam && SIZE_MINIMIZED !=m_uPrevSize)
  249.             {
  250.             //When we change size, resize any Polyline we hold.
  251.             dx=LOWORD(lParam);
  252.             dy=HIWORD(lParam);
  253.  
  254.             /*
  255.              * If we are getting WM_SIZE in response to a Polyline
  256.              * notification, then don't resize the Polyline window again.
  257.              */
  258.             if (!m_fNoSize && NULL!=m_pPL)
  259.                 {
  260.                 //Resize the polyline to fit the new client
  261.                 SetRect(&rc, 8, 8, dx-8, dy-8);
  262.                 m_pPL->RectSet(&rc, FALSE);
  263.  
  264.                 /*
  265.                  * We consider sizing something that makes the file dirty,
  266.                  * but not until we've finished the create process, which
  267.                  * is why we set fNoDirty to FALSE in WM_CREATE since we
  268.                  * get a WM_SIZE on the first creation.
  269.                  */
  270.                 if (!m_fNoDirty)
  271.                     FDirtySet(TRUE);
  272.  
  273.                 SetRect(&rc, 0, 0, dx, dy);
  274.  
  275.                 if (NULL!=m_pAdv)
  276.                     m_pAdv->OnSizeChange((LPCDocument)this, &rc);
  277.  
  278.                 m_fNoDirty=FALSE;
  279.                 }
  280.             }
  281.  
  282.         m_uPrevSize=wParam;
  283.         }
  284.  
  285.     /*
  286.      * We return FALSE even on WM_SIZE so we can let the default procedure
  287.      * handle maximized MDI child windows appropriately.
  288.      */
  289.     return FALSE;
  290.     }
  291.  
  292.  
  293.  
  294.  
  295.  
  296.  
  297.  
  298.  
  299. /*
  300.  * CSchmooDoc::Clear
  301.  *
  302.  * Purpose:
  303.  *  Sets all contents in the document back to defaults with no filename.
  304.  *
  305.  * Paramters:
  306.  *  None
  307.  *
  308.  * Return Value:
  309.  *  None
  310.  */
  311.  
  312. void CSchmooDoc::Clear(void)
  313.     {
  314.     //Completely reset the polyline
  315.     m_pPL->New();
  316.  
  317.     CDocument::Clear();
  318.     return;
  319.     }
  320.  
  321.  
  322.  
  323.  
  324.  
  325.  
  326. /*
  327.  * CSchmooDoc::ULoad
  328.  *
  329.  * Purpose:
  330.  *  Loads a given document without any user interface overwriting the
  331.  *  previous contents of the Polyline window.  We do this by opening
  332.  *  the file and telling the Polyline to load itself from that file.
  333.  *
  334.  * Parameters:
  335.  *  fChangeFile     BOOL indicating if we're to update the window title
  336.  *                  and the filename from using this file.
  337.  *  pszFile         LPSTR to the filename to load, NULL for untitled.
  338.  *
  339.  * Return Value:
  340.  *  UINT            An error value from DOCERR_*
  341.  */
  342.  
  343. UINT CSchmooDoc::ULoad(BOOL fChangeFile, LPSTR pszFile)
  344.     {
  345.     HRESULT             hr;
  346.     LPSTORAGE           pIStorage;
  347.  
  348.     if (NULL==pszFile)
  349.         {
  350.         /*
  351.          * As a user of an IPersistStorage we have to provide all objects
  352.          * with an IStorage they can use for incremental access passing
  353.          * that storage to ::InitNew.  Here we create a temporary file
  354.          * that we don't bother holding on to.  If the object doesn't
  355.          * use it, then our ::Release destroys it immediately.
  356.          */
  357.  
  358.         hr=StgCreateDocfile(NULL, STGM_DIRECT | STGM_READWRITE | STGM_CREATE
  359.             | STGM_DELETEONRELEASE | STGM_SHARE_EXCLUSIVE, 0, &pIStorage);
  360.  
  361.         if (FAILED(hr))
  362.             return DOCERR_COULDNOTOPEN;
  363.  
  364.         m_pIPersistStorage->InitNew(pIStorage);
  365.         pIStorage->Release();
  366.  
  367.         Rename(NULL);
  368.         return DOCERR_NONE;
  369.         }
  370.  
  371.     /*
  372.      * Open a storage and pass it to the Polyline via IPersistStorage.
  373.      * We do not remain compatible with previous files saved with
  374.      * Component Schmoo.
  375.      */
  376.  
  377.     hr=StgOpenStorage(pszFile, NULL, STGM_DIRECT | STGM_READ
  378.         | STGM_SHARE_EXCLUSIVE, NULL, 0, &pIStorage);
  379.  
  380.     if (FAILED(hr))
  381.         return DOCERR_COULDNOTOPEN;
  382.  
  383.     hr=m_pIPersistStorage->Load(pIStorage);
  384.  
  385.     pIStorage->Release();
  386.  
  387.     if (FAILED(hr))
  388.         return DOCERR_READFAILURE;
  389.  
  390.     if (fChangeFile)
  391.         Rename(pszFile);
  392.  
  393.     //Importing a file makes things dirty
  394.     FDirtySet(!fChangeFile);
  395.  
  396.     return DOCERR_NONE;
  397.     }
  398.  
  399.  
  400.  
  401.  
  402.  
  403.  
  404.  
  405. /*
  406.  * CSchmooDoc::USave
  407.  *
  408.  * Purpose:
  409.  *  Writes the file to a known filename, requiring that the user has
  410.  *  previously used FileOpen or FileSaveAs in order to have a filename.
  411.  *
  412.  * Parameters:
  413.  *  uType           UINT indicating the type of file the user requested
  414.  *                  to save in the File Save As dialog.
  415.  *  pszFile         LPSTR under which to save.  If NULL, use the current name.
  416.  *
  417.  * Return Value:
  418.  *  UINT            An error value from DOCERR_*
  419.  */
  420.  
  421. UINT CSchmooDoc::USave(UINT uType, LPSTR pszFile)
  422.     {
  423.     BOOL                fRename=TRUE;
  424.     HRESULT             hr;
  425.     LPSTORAGE           pIStorage;
  426.  
  427.     if (NULL==pszFile)
  428.         {
  429.         fRename=FALSE;
  430.         pszFile=m_szFile;
  431.         }
  432.  
  433.     /*
  434.      * In Component Schmoo, we only deal with one version of data,
  435.      * so all the code in Chapter 2 Schmoo that dealt with 1.0 and
  436.      * 2.0 files has been removed.
  437.      */
  438.  
  439.     hr=StgCreateDocfile(pszFile, STGM_DIRECT | STGM_READWRITE
  440.         | STGM_CREATE | STGM_SHARE_EXCLUSIVE, 0, &pIStorage);
  441.  
  442.     if (FAILED(hr))
  443.         return DOCERR_COULDNOTOPEN;
  444.  
  445.     //Tell the object to save, and also tell it that we're done.
  446.     m_pIPersistStorage->Save(pIStorage, FALSE);
  447.     m_pIPersistStorage->SaveCompleted(pIStorage);
  448.  
  449.     pIStorage->Release();
  450.  
  451.     if (FAILED(hr))
  452.         return DOCERR_WRITEFAILURE;
  453.  
  454.     //Saving makes us clean
  455.     FDirtySet(FALSE);
  456.  
  457.     if (fRename)
  458.         Rename(pszFile);
  459.  
  460.     return DOCERR_NONE;
  461.     }
  462.  
  463.  
  464.  
  465. /*
  466.  * CSchmooDoc::Undo
  467.  *
  468.  * Purpose:
  469.  *  Reverses a previous action.
  470.  *
  471.  * Parameters:
  472.  *  None
  473.  *
  474.  * Return Value:
  475.  *  None
  476.  */
  477.  
  478. void CSchmooDoc::Undo(void)
  479.     {
  480.     m_pPL->Undo();
  481.     return;
  482.     }
  483.  
  484.  
  485.  
  486.  
  487.  
  488.  
  489. /*
  490.  * CSchmooDoc::FClip
  491.  *
  492.  * Purpose:
  493.  *  Places a private format, a metafile, and a bitmap of the display
  494.  *  on the clipboard, optionally implementing Cut by deleting the
  495.  *  data in the current window after rendering.
  496.  *
  497.  * Parameters:
  498.  *  hWndFrame       HWND of the main window.
  499.  *  fCut            BOOL indicating cut (TRUE) or copy (FALSE).
  500.  *
  501.  * Return Value:
  502.  *  BOOL            TRUE if successful, FALSE otherwise.
  503.  */
  504.  
  505. BOOL CSchmooDoc::FClip(HWND hWndFrame, BOOL fCut)
  506.     {
  507.     //CHAPTER7MOD
  508.     LPPOLYLINE              pPL;
  509.     LPDATAOBJECT            pDataSrc, pDataDst;
  510.     FORMATETC               fe;
  511.     STGMEDIUM               stm;
  512.     BOOL                    fRet=TRUE;
  513.     HRESULT                 hr;
  514.     RECT                    rc;
  515.  
  516.     //Create a transfer Polyline Object
  517.     hr=CoCreateInstance(CLSID_Polyline6, NULL, CLSCTX_INPROC_SERVER
  518.         , IID_IPolyline6, (LPVOID FAR *)&pPL);
  519.  
  520.     if (FAILED(hr))
  521.         return FALSE;
  522.  
  523.     //Make the new transfer Polyline same size as the current one.
  524.     m_pPL->RectGet(&rc);
  525.  
  526.     if (FAILED(pPL->Init(m_hWnd, &rc, WS_CHILD, ID_POLYLINE)))
  527.         {
  528.         pPL->Release();
  529.         return FALSE;
  530.         }
  531.  
  532.     /*
  533.      * Now that we have the new object, get IDataObject interfaces on
  534.      * both that one and the new one we hold, then copy the data from
  535.      * the current to the new.
  536.      */
  537.  
  538.     m_pPL->QueryInterface(IID_IDataObject, (LPVOID FAR *)&pDataSrc);
  539.  
  540.     SETDefFormatEtc(fe, m_cf, TYMED_HGLOBAL);
  541.     fRet=SUCCEEDED(pDataSrc->GetData(&fe, &stm));
  542.     pDataSrc->Release();
  543.  
  544.     if (!fRet)
  545.         {
  546.         pPL->Release();
  547.         return FALSE;
  548.         }
  549.  
  550.     pPL->QueryInterface(IID_IDataObject, (LPVOID FAR *)&pDataDst);
  551.     pPL->Release();
  552.  
  553.     pDataDst->SetData(&fe, &stm, TRUE);
  554.  
  555.     fRet=SUCCEEDED(OleSetClipboard((LPDATAOBJECT)pDataDst));
  556.  
  557.     /*
  558.      * OleSetClipboard, if it wants to hold the object, will AddRef it,
  559.      * so we can release all our pointers.  The only remaining ref
  560.      * counts on the new Polyline will be owned by OLE, so when OLE
  561.      * releases it, the Polyline is freed.
  562.      */
  563.  
  564.     pDataDst->Release();
  565.  
  566.     if (!fRet)
  567.         return FALSE;
  568.  
  569.     if (fCut)
  570.         {
  571.         m_pPL->New();
  572.         FDirtySet(TRUE);
  573.         }
  574.  
  575.     return TRUE;
  576.     //End CHAPTER7MOD
  577.     }
  578.  
  579.  
  580.  
  581.  
  582. //CHAPTER7MOD
  583. //CSchmooDoc::RenderFormat no longer necessary.
  584. //End CHAPTER7MOD
  585.  
  586.  
  587.  
  588.  
  589.  
  590. /*
  591.  * CSchmooDoc::FQueryPaste
  592.  *
  593.  * Purpose:
  594.  *  Determines if we can paste data from the clipboard.
  595.  *
  596.  * Parameters:
  597.  *  None
  598.  *
  599.  * Return Value:
  600.  *  BOOL            TRUE if data is available, FALSE otherwise.
  601.  */
  602.  
  603. BOOL CSchmooDoc::FQueryPaste(void)
  604.     {
  605.     //CHAPTER7MOD
  606.     LPDATAOBJECT    pIDataObject;
  607.     FORMATETC       fe;
  608.     BOOL            fRet;
  609.  
  610.     if (FAILED(OleGetClipboard(&pIDataObject)))
  611.         return FALSE;
  612.  
  613.     SETDefFormatEtc(fe, m_cf, TYMED_HGLOBAL);
  614.     fRet=(NOERROR==pIDataObject->QueryGetData(&fe));
  615.  
  616.     pIDataObject->Release();
  617.     return fRet;
  618.     //End CHAPTER7MOD
  619.     }
  620.  
  621.  
  622.  
  623.  
  624.  
  625. /*
  626.  * CSchmooDoc::FPaste
  627.  *
  628.  * Purpose:
  629.  *  Retrieves the private data format from the clipboard and sets it
  630.  *  to the current figure in the editor window.
  631.  *
  632.  *  Note that if this function is called, then the clipboard format
  633.  *  is available because the Paste menu item is only enabled if the
  634.  *  format is present.
  635.  *
  636.  * Parameters:
  637.  *  hWndFrame       HWND of the main window.
  638.  *
  639.  * Return Value:
  640.  *  BOOL            TRUE if successful, FALSE otherwise.
  641.  */
  642.  
  643. BOOL CSchmooDoc::FPaste(HWND hWndFrame)
  644.     {
  645.     //CHAPTER7MOD
  646.     LPDATAOBJECT    pIDataObject;
  647.     FORMATETC       fe;
  648.     STGMEDIUM       stm;
  649.     BOOL            fRet;
  650.  
  651.     if (FAILED(OleGetClipboard(&pIDataObject)))
  652.         return FALSE;
  653.  
  654.     SETDefFormatEtc(fe, m_cf, TYMED_HGLOBAL);
  655.     fRet=SUCCEEDED(pIDataObject->GetData(&fe, &stm));
  656.     pIDataObject->Release();
  657.  
  658.     if (!fRet || NULL==stm.hGlobal)
  659.         return FALSE;
  660.  
  661.     //Send the data to the Polyline now.
  662.     m_pPL->QueryInterface(IID_IDataObject, (LPVOID FAR *)&pIDataObject);
  663.     pIDataObject->SetData(&fe, &stm, TRUE);
  664.     pIDataObject->Release();
  665.  
  666.     FDirtySet(TRUE);
  667.  
  668.     //End CHAPTER7MOD
  669.     return TRUE;
  670.     }
  671.  
  672.  
  673.  
  674.  
  675.  
  676.  
  677.  
  678.  
  679. /*
  680.  * CSchmooDoc::ColorSet
  681.  *
  682.  * Purpose:
  683.  *  Changes a color used in our contained Polyline.
  684.  *
  685.  * Parameters:
  686.  *  iColor          UINT index of the color to change.
  687.  *  cr              COLORREF new color.
  688.  *
  689.  * Return Value:
  690.  *  COLORREF        Previous color for the given index.
  691.  */
  692.  
  693. COLORREF CSchmooDoc::ColorSet(UINT iColor, COLORREF cr)
  694.     {
  695.     COLORREF    crRet;
  696.  
  697.     m_pPL->ColorSet(iColor, cr, &crRet);
  698.     return crRet;
  699.     }
  700.  
  701.  
  702.  
  703.  
  704.  
  705. /*
  706.  * CSchmooDoc::ColorGet
  707.  *
  708.  * Purpose:
  709.  *  Retrieves a color currently in use in the Polyline.
  710.  *
  711.  * Parameters:
  712.  *  iColor          UINT index of the color to retrieve.
  713.  *
  714.  * Return Value:
  715.  *  COLORREF        Current color for the given index.
  716.  */
  717.  
  718. COLORREF CSchmooDoc::ColorGet(UINT iColor)
  719.     {
  720.     COLORREF    crRet;
  721.  
  722.     m_pPL->ColorGet(iColor, &crRet);
  723.     return crRet;
  724.     }
  725.  
  726.  
  727.  
  728.  
  729.  
  730.  
  731. /*
  732.  * CSchmooDoc::LineStyleSet
  733.  *
  734.  * Purpose:
  735.  *  Changes the line style currently used in the Polyline
  736.  *
  737.  * Parameters:
  738.  *  iStyle          UINT index of the new line style to use.
  739.  *
  740.  * Return Value:
  741.  *  UINT            Previous line style.
  742.  */
  743.  
  744.  
  745. UINT CSchmooDoc::LineStyleSet(UINT iStyle)
  746.     {
  747.     UINT    i;
  748.  
  749.     m_pPL->LineStyleSet(iStyle, &i);
  750.     return i;
  751.     }
  752.  
  753.  
  754.  
  755.  
  756.  
  757.  
  758.  
  759. /*
  760.  * CSchmooDoc::LineStyleGet
  761.  *
  762.  * Purpose:
  763.  *  Retrieves the line style currently used in the Polyline
  764.  *
  765.  * Parameters:
  766.  *  None
  767.  *
  768.  * Return Value:
  769.  *  UINT            Current line style.
  770.  */
  771.  
  772.  
  773. UINT CSchmooDoc::LineStyleGet(void)
  774.     {
  775.     UINT    i;
  776.  
  777.     m_pPL->LineStyleGet(&i);
  778.     return i;
  779.     }
  780.  
  781.  
  782.  
  783. //CPolylineAdviseSink moved to IADVSINK.CPP
  784.